home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 14 / CU Amiga Magazine's Super CD-ROM 14 (1997)(EMAP Images)(GB)(Track 1 of 3)[!][issue 1997-09].iso / CUCD / Programming / Mesa-2.2 / src / image.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-13  |  18.4 KB  |  618 lines
  1. /* $Id: image.c,v 1.9 1997/02/09 20:05:03 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  2.2
  6.  * Copyright (C) 1995-1997  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: image.c,v $
  26.  * Revision 1.9  1997/02/09 20:05:03  brianp
  27.  * new arguments for gl_pixel_addr_in_image()
  28.  *
  29.  * Revision 1.8  1997/02/09 18:52:53  brianp
  30.  * added GL_EXT_texture3D support
  31.  *
  32.  * Revision 1.7  1997/01/09 21:25:54  brianp
  33.  * initialize image reference count to zero
  34.  *
  35.  * Revision 1.6  1996/11/13 03:58:31  brianp
  36.  * fixed undefined "format" variable in gl_unpack_image()
  37.  *
  38.  * Revision 1.5  1996/11/10 17:48:03  brianp
  39.  * check if format is GL_DEPTH_COMPONENT or GL_STENCIL_COMPONENT
  40.  *
  41.  * Revision 1.4  1996/11/06 04:23:01  brianp
  42.  * changed gl_unpack_image() components argument to srcFormat
  43.  *
  44.  * Revision 1.3  1996/09/27 01:27:10  brianp
  45.  * removed unused variables
  46.  *
  47.  * Revision 1.2  1996/09/26 22:35:10  brianp
  48.  * fixed a few compiler warnings from IRIX 6 -n32 and -64 compiler
  49.  *
  50.  * Revision 1.1  1996/09/13 01:38:16  brianp
  51.  * Initial revision
  52.  *
  53.  */
  54.  
  55.  
  56. #include <assert.h>
  57. #include <stdlib.h>
  58. #include <string.h>
  59. #include "image.h"
  60. #include "macros.h"
  61. #include "pixel.h"
  62. #include "types.h"
  63.  
  64.  
  65.  
  66.  
  67. /*
  68.  * Flip the 8 bits in each byte of the given array.
  69.  */
  70. void gl_flip_bytes( GLubyte *p, GLuint n )
  71. {
  72.    register GLuint i, a, b;
  73.  
  74.    for (i=0;i<n;i++) {
  75.       b = (GLuint) p[i];
  76.       a = ((b & 0x01) << 7) |
  77.       ((b & 0x02) << 5) |
  78.       ((b & 0x04) << 3) |
  79.       ((b & 0x08) << 1) |
  80.       ((b & 0x10) >> 1) |
  81.       ((b & 0x20) >> 3) |
  82.       ((b & 0x40) >> 5) |
  83.       ((b & 0x80) >> 7);
  84.       p[i] = (GLubyte) a;
  85.    }
  86. }
  87.  
  88.  
  89. /*
  90.  * Flip the order of the 2 bytes in each word in the given array.
  91.  */
  92. void gl_swap2( GLushort *p, GLuint n )
  93. {
  94.    register GLuint i;
  95.  
  96.    for (i=0;i<n;i++) {
  97.       p[i] = (p[i] >> 8) | ((p[i] << 8) & 0xff00);
  98.    }
  99. }
  100.  
  101.  
  102.  
  103. /*
  104.  * Flip the order of the 4 bytes in each word in the given array.
  105.  */
  106. void gl_swap4( GLuint *p, GLuint n )
  107. {
  108.    register GLuint i, a, b;
  109.  
  110.    for (i=0;i<n;i++) {
  111.       b = p[i];
  112.       a =  (b >> 24)
  113.     | ((b >> 8) & 0xff00)
  114.     | ((b << 8) & 0xff0000)
  115.     | ((b << 24) & 0xff000000);
  116.       p[i] = a;
  117.    }
  118. }
  119.  
  120.  
  121.  
  122.  
  123. /*
  124.  * Return the size, in bytes, of the given GL datatype.
  125.  * Return 0 if GL_BITMAP.
  126.  * Return -1 if invalid type enum.
  127.  */
  128. GLint gl_sizeof_type( GLenum type )
  129. {
  130.    switch (type) {
  131.       case GL_BITMAP:
  132.      return 0;
  133.       case GL_UNSIGNED_BYTE:
  134.          return sizeof(GLubyte);
  135.       case GL_BYTE:
  136.      return sizeof(GLbyte);
  137.       case GL_UNSIGNED_SHORT:
  138.      return sizeof(GLushort);
  139.       case GL_SHORT:
  140.      return sizeof(GLshort);
  141.       case GL_UNSIGNED_INT:
  142.      return sizeof(GLuint);
  143.       case GL_INT:
  144.      return sizeof(GLint);
  145.       case GL_FLOAT:
  146.      return sizeof(GLfloat);
  147.       default:
  148.          return -1;
  149.    }
  150. }
  151.  
  152.  
  153.  
  154. /*
  155.  * Return the number of components in a GL enum pixel type.
  156.  * Return -1 if bad format.
  157.  */
  158. GLint gl_components_in_format( GLenum format )
  159. {
  160.    switch (format) {
  161.       case GL_COLOR_INDEX:
  162.       case GL_STENCIL_INDEX:
  163.       case GL_DEPTH_COMPONENT:
  164.       case GL_RED:
  165.       case GL_GREEN:
  166.       case GL_BLUE:
  167.       case GL_ALPHA:
  168.       case GL_LUMINANCE:
  169.          return 1;
  170.       case GL_LUMINANCE_ALPHA:
  171.      return 2;
  172.       case GL_RGB:
  173.      return 3;
  174.       case GL_RGBA:
  175.      return 4;
  176.       default:
  177.          return -1;
  178.    }
  179. }
  180.  
  181.  
  182. /*
  183.  * Return the address of a pixel in an image (actually a volume).
  184.  * Pixel unpacking/packing parameters are observed according to 'packing'.
  185.  * Input:  image - start of image data
  186.  *         width, height - size of image
  187.  *         format - image format
  188.  *         type - pixel component type
  189.  *         packing - GL_TRUE = use packing params
  190.  *                   GL_FALSE = use unpacking params.
  191.  *         img - which image in the volume (0 for 2-D images)
  192.  *         row, column - location of pixel in the image
  193.  * Return:  address of pixel at (image,row,column) in image or NULL if error.
  194.  */
  195. GLvoid *gl_pixel_addr_in_image( struct gl_pixelstore_attrib *packing,
  196.                                 const GLvoid *image, GLsizei width,
  197.                                 GLsizei height, GLenum format, GLenum type,
  198.                                 GLint img, GLint row, GLint column )
  199. {
  200.    GLint bytes_per_comp;   /* bytes per component */
  201.    GLint comp_per_pixel;   /* components per pixel */
  202.    GLint comps_per_row;    /* components per row */
  203.    GLint pixels_per_row;   /* pixels per row */
  204.    GLint bytes_per_image;
  205.    GLint rows_per_image;
  206.    GLint alignment;        /* 1, 2 or 4 */
  207.    GLint skiprows;
  208.    GLint skippixels;
  209.    GLint skipimages;       /* for 3-D */
  210.    GLubyte *pixel_addr;
  211.  
  212.    /* Compute bytes per component */
  213.    bytes_per_comp = gl_sizeof_type( type );
  214.    if (bytes_per_comp<0) {
  215.       return NULL;
  216.    }
  217.  
  218.    /* Compute number of components per pixel */
  219.    comp_per_pixel = gl_components_in_format( format );
  220.    if (comp_per_pixel<0) {
  221.       return NULL;
  222.    }
  223.  
  224.    alignment = packing->Alignment;
  225.    if (packing->RowLength>0) {
  226.       pixels_per_row = packing->RowLength;
  227.    }
  228.    else {
  229.       pixels_per_row = width;
  230.    }
  231.    if (packing->ImageHeight>0) {
  232.       rows_per_image = packing->ImageHeight;
  233.    }
  234.    else {
  235.       rows_per_image = height;
  236.    }
  237.    skiprows = packing->SkipRows;
  238.    skippixels = packing->SkipPixels;
  239.    skipimages = packing->SkipImages;
  240.  
  241.    if (type==GL_BITMAP) {
  242.       /* BITMAP data */
  243.       GLint bytes_per_row;
  244.  
  245.       bytes_per_row = alignment
  246.                     * CEILING( comp_per_pixel*pixels_per_row, 8*alignment );
  247.  
  248.       bytes_per_image = bytes_per_row * rows_per_image;
  249.  
  250.       pixel_addr = (GLubyte *) image
  251.                  + (skipimages + img) * bytes_per_image
  252.                  + (skiprows + row) * bytes_per_row
  253.                  + (skippixels + column) / 8;
  254.    }
  255.    else {
  256.       /* Non-BITMAP data */
  257.  
  258.       if (bytes_per_comp>=alignment) {
  259.      comps_per_row = comp_per_pixel * pixels_per_row;
  260.       }
  261.       else {
  262.          GLint bytes_per_row = bytes_per_comp * comp_per_pixel
  263.                              * pixels_per_row;
  264.  
  265.      comps_per_row = alignment / bytes_per_comp
  266.                        * CEILING( bytes_per_row, alignment );
  267.       }
  268.  
  269.       bytes_per_image = bytes_per_comp * comps_per_row * rows_per_image;
  270.  
  271.       /* Copy/unpack pixel data to buffer */
  272.       pixel_addr = (GLubyte *) image
  273.                  + (skipimages + img) * bytes_per_image
  274.                  + (skiprows + row) * bytes_per_comp * comps_per_row
  275.                  + (skippixels + column) * bytes_per_comp * comp_per_pixel;
  276.    }
  277.  
  278.    return (GLvoid *) pixel_addr;
  279. }
  280.  
  281.  
  282.  
  283. /*
  284.  * Unpack a 2-D image from user-supplied address, returning a pointer to
  285.  * a new gl_image struct.
  286.  * This function is always called by a higher-level unpack function such
  287.  * as gl_unpack_texsubimage() or gl_unpack_bitmap().
  288.  *
  289.  * Input:  width, height - size in pixels
  290.  *         srcFormat - format of incoming pixel data, ignored
  291.  *                      if srcType and destType is BITMAP.
  292.  *         srcType - GL_UNSIGNED_BYTE .. GL_FLOAT
  293.  *         destType - store image as GL_UNSIGNED_BYTE, GL_FLOAT, or GL_BITMAP.
  294.  *                    if GL_UNSIGNED_BYTE, srctype must be GL_UNSIGNED_BYTE.
  295.  *                    if GL_BITMAP, srctype must be GL_BITMAP.
  296.  *         interleave - if TRUE, srctype and destType must be GL_UNSIGNED_BYTE
  297.  *         pixels - pointer to unpacked image.
  298.  */
  299. struct gl_image *gl_unpack_image( GLcontext *ctx,
  300.                                   GLint width, GLint height,
  301.                                   GLenum srcFormat, GLenum srcType,
  302.                                   GLenum destType,
  303.                                   const GLvoid *pixels,
  304.                                   GLboolean interleave )
  305. { 
  306.    return gl_unpack_image3D(ctx, width, height, 1,
  307.                             srcFormat, srcType, destType, pixels, interleave);
  308. }
  309.  
  310.  
  311.  
  312. /* 
  313.  * Unpack a 2-D/3-D image from user-supplied address, returning a pointer to
  314.  * a new gl_image struct.
  315.  * This function is always called by a higher-level unpack function such
  316.  * as gl_unpack_texsubimage() or gl_unpack_bitmap().
  317.  *
  318.  * Input:  width, height, depth - size in pixels
  319.  *         srcFormat - format of incoming pixel data, ignored
  320.  *                      if srcType and destType is BITMAP.
  321.  *         srcType - GL_UNSIGNED_BYTE .. GL_FLOAT
  322.  *         destType - store image as GL_UNSIGNED_BYTE, GL_FLOAT, or GL_BITMAP.
  323.  *                    if GL_UNSIGNED_BYTE, srctype must be GL_UNSIGNED_BYTE.
  324.  *                    if GL_BITMAP, srctype must be GL_BITMAP.
  325.  *         interleave - if TRUE, srctype and destType must be GL_UNSIGNED_BYTE
  326.  *         pixels - pointer to unpacked image.
  327.  */
  328. struct gl_image *gl_unpack_image3D( GLcontext *ctx,
  329.                                     GLint width, GLint height, GLint depth,
  330.                                     GLenum srcFormat, GLenum srcType,
  331.                                     GLenum destType,
  332.                                     const GLvoid *pixels,
  333.                                     GLboolean interleave )
  334. {
  335.    GLint components;
  336.  
  337.    components = gl_components_in_format( srcFormat );
  338.  
  339.    if (srcType==GL_BITMAP || destType==GL_BITMAP) {
  340.       struct gl_image *image;
  341.       GLint bytes, i, width_in_bytes, d;
  342.       GLubyte *buffer, *dst;
  343.       assert( srcType==GL_BITMAP );
  344.       assert( destType==GL_BITMAP );
  345.  
  346.       /* Alloc dest storage */
  347.       bytes = ((width+7)/8 * height) * depth;
  348.       if (bytes>0 && pixels!=NULL) {
  349.          buffer = (GLubyte *) malloc( bytes );
  350.          if (!buffer) {
  351.             return NULL;
  352.          }
  353.          /* Copy/unpack pixel data to buffer */
  354.          width_in_bytes = CEILING( width, 8 );
  355.          dst = buffer;
  356.          for (d=0; d<depth; d++) {
  357.             for (i=0; i<height; i++) {
  358.                GLvoid *src = gl_pixel_addr_in_image( &ctx->Unpack, pixels,
  359.                                                      width, height,
  360.                                                      GL_COLOR_INDEX, srcType,
  361.                                                      d, i, 0 );
  362.                if (!src) {
  363.                   free(buffer);
  364.                   return NULL;
  365.                }
  366.                MEMCPY( dst, src, width_in_bytes );
  367.                dst += width_in_bytes;
  368.             }
  369.          }
  370.          /* Bit flipping */
  371.          if (ctx->Unpack.LsbFirst) {
  372.             gl_flip_bytes( buffer, bytes );
  373.          }
  374.       }
  375.       else {
  376.          /* a 'null' bitmap */
  377.          buffer = NULL;
  378.       }
  379.  
  380.       image = (struct gl_image *) malloc( sizeof(struct gl_image) );
  381.       if (image) {
  382.          image->Width = width;
  383.          image->Height = height;
  384.          image->Depth = depth;
  385.          image->Components = 0;
  386.          image->Format = GL_COLOR_INDEX;
  387.          image->Type = GL_BITMAP;
  388.          image->Interleaved = GL_FALSE;
  389.          image->Data = buffer;
  390.          image->RefCount = 0;
  391.       }
  392.       else {
  393.          free( buffer );
  394.          return NULL;
  395.       }
  396.       return image;
  397.    }
  398.    else if (srcFormat==GL_DEPTH_COMPONENT) {
  399.       /* TODO: pack as GLdepth values (GLushort or GLuint) */
  400.  
  401.    }
  402.    else if (srcFormat==GL_STENCIL_INDEX) {
  403.       /* TODO: pack as GLstencil (GLubyte or GLushort) */
  404.  
  405.    }
  406.    else if (destType==GL_UNSIGNED_BYTE) {
  407.       struct gl_image *image;
  408.       GLint width_in_bytes;
  409.       GLubyte *buffer, *dst;
  410.       GLint i, d;
  411.       assert( srcType==GL_UNSIGNED_BYTE );
  412.  
  413.       width_in_bytes = width * components * sizeof(GLubyte);
  414.       buffer = malloc( height * width_in_bytes * depth );
  415.       if (!buffer) {
  416.          return NULL;
  417.       }
  418.       /* Copy/unpack pixel data to buffer */
  419.       dst = buffer;
  420.       for (d=0; d<depth; d++ ) {
  421.          for (i=0;i<height;i++) {
  422.             GLubyte *src = (GLubyte *) gl_pixel_addr_in_image( &ctx->Unpack,
  423.                            pixels, width, height, srcFormat, srcType, d, i, 0 );
  424.             if (!src) {
  425.                free(buffer);
  426.                return NULL;
  427.             }
  428.             if (interleave) {
  429.                GLint j, k;
  430.                for (j=0;j<width;j++) {
  431.                   for (k=0;k<components;k++) {
  432.                      dst[k*width+j] = src[j*components+k];
  433.                   }
  434.                }
  435.             }
  436.             else {
  437.                MEMCPY( dst, src, width_in_bytes );
  438.             }
  439.             dst += width_in_bytes;
  440.          }
  441.       }
  442.  
  443.       if (ctx->Unpack.LsbFirst) {
  444.          gl_flip_bytes( buffer, height * width_in_bytes * depth );
  445.       }
  446.  
  447.       image = (struct gl_image *) malloc( sizeof(struct gl_image) );
  448.       if (image) {
  449.          image->Width = width;
  450.          image->Height = height;
  451.          image->Depth = depth; 
  452.          image->Components = components;
  453.          image->Format = srcFormat;
  454.          image->Type = GL_UNSIGNED_BYTE;
  455.          image->Interleaved = interleave;
  456.          image->Data = buffer;
  457.       }
  458.       else {
  459.          free( buffer );
  460.          return NULL;
  461.       }
  462.       return image;
  463.    }
  464.    else if (destType==GL_FLOAT) {
  465.       struct gl_image *image;
  466.       GLfloat *buffer, *dst;
  467.       GLint elems_per_row;
  468.       GLint i, j, d;
  469.       elems_per_row = width * components;
  470.       buffer = (GLfloat *) malloc( height * elems_per_row * sizeof(GLfloat) * depth);
  471.       if (!buffer) {
  472.          return NULL;
  473.       }
  474.  
  475.       dst = buffer;
  476.       /**      img_pixels= pixels;*/
  477.       for (d=0; d<depth; d++) {
  478.          for (i=0;i<height;i++) {
  479.             GLvoid *src = gl_pixel_addr_in_image( &ctx->Unpack, pixels,
  480.                                                   width, height,
  481.                                                   srcFormat, srcType,
  482.                                                   d, i, 0 );
  483.             if (!src) {
  484.                free(buffer);
  485.                return NULL;
  486.             }
  487.  
  488.             switch (srcType) {
  489.                case GL_UNSIGNED_BYTE:
  490.                   for (j=0;j<elems_per_row;j++) {
  491.                      *dst++ = (GLfloat) ((GLubyte*)src)[j];
  492.                   }
  493.                   break;
  494.                case GL_BYTE:
  495.                   for (j=0;j<elems_per_row;j++) {
  496.                      *dst++ = (GLfloat) ((GLbyte*)src)[j];
  497.                   }
  498.                   break;
  499.                case GL_UNSIGNED_SHORT:
  500.                   if (ctx->Unpack.SwapBytes) {
  501.                      for (j=0;j<elems_per_row;j++) {
  502.                         GLushort value = ((GLushort*)src)[j];
  503.                         value = ((value >> 8) & 0xff) | ((value&0xff) << 8);
  504.                         *dst++ = (GLfloat) value;
  505.                      }
  506.                   }
  507.                   else {
  508.                      for (j=0;j<elems_per_row;j++) {
  509.                         *dst++ = (GLfloat) ((GLushort*)src)[j];
  510.                      }
  511.                   }
  512.                   break;
  513.                case GL_SHORT:
  514.                   if (ctx->Unpack.SwapBytes) {
  515.                      for (j=0;j<elems_per_row;j++) {
  516.                         GLshort value = ((GLshort*)src)[j];
  517.                         value = ((value >> 8) & 0xff) | ((value&0xff) << 8);
  518.                         *dst++ = (GLfloat) value;
  519.                      }
  520.                   }
  521.                   else {
  522.                      for (j=0;j<elems_per_row;j++) {
  523.                         *dst++ = (GLfloat) ((GLshort*)src)[j];
  524.                      }
  525.                   }
  526.                   break;
  527.                case GL_UNSIGNED_INT:
  528.                   if (ctx->Unpack.SwapBytes) {
  529.                      GLuint value;
  530.                      for (j=0;j<elems_per_row;j++) {
  531.                         value = ((GLuint*)src)[j];
  532.                         value = ((value & 0xff000000) >> 24)
  533.                               | ((value & 0x00ff0000) >> 8)
  534.                               | ((value & 0x0000ff00) << 8)
  535.                               | ((value & 0x000000ff) << 24);
  536.                         *dst++ = (GLfloat) value;
  537.                      }
  538.                   }
  539.                   else {
  540.                      for (j=0;j<elems_per_row;j++) {
  541.                         *dst++ = (GLfloat) ((GLuint*)src)[j];
  542.                      }
  543.                   }
  544.                   break;
  545.                case GL_INT:
  546.                   if (ctx->Unpack.SwapBytes) {
  547.                      GLint value;
  548.                      for (j=0;j<elems_per_row;j++) {
  549.                         value = ((GLint*)src)[j];
  550.                         value = ((value & 0xff000000) >> 24)
  551.                               | ((value & 0x00ff0000) >> 8)
  552.                               | ((value & 0x0000ff00) << 8)
  553.                               | ((value & 0x000000ff) << 24);
  554.                         *dst++ = (GLfloat) value;
  555.                      }
  556.                   }
  557.                   else {
  558.                      for (j=0;j<elems_per_row;j++) {
  559.                         *dst++ = (GLfloat) ((GLint*)src)[j];
  560.                      }
  561.                   }
  562.                   break;
  563.                case GL_FLOAT:
  564.                   if (ctx->Unpack.SwapBytes) {
  565.                      GLint value;
  566.                      for (j=0;j<elems_per_row;j++) {
  567.                         value = ((GLuint*)src)[j];
  568.                         value = ((value & 0xff000000) >> 24)
  569.                               | ((value & 0x00ff0000) >> 8)
  570.                               | ((value & 0x0000ff00) << 8)
  571.                               | ((value & 0x000000ff) << 24);
  572.                         *dst++ = *((GLfloat*) &value);
  573.                      }
  574.                   }
  575.                   else {
  576.                      MEMCPY( dst, src, elems_per_row*sizeof(GLfloat) );
  577.                      dst += elems_per_row;
  578.                   }
  579.                   break;
  580.                default:
  581.                   abort();
  582.             } /*switch*/
  583.          } /* for height */
  584.       } /*for*/
  585.  
  586.       image = (struct gl_image *) malloc( sizeof(struct gl_image) );
  587.       if (image) {
  588.          image->Width = width;
  589.          image->Height = height;
  590.          image->Depth = depth;  
  591.          image->Components = components;
  592.          image->Format = srcFormat;
  593.          image->Type = GL_FLOAT;
  594.          image->Interleaved = GL_FALSE;
  595.          image->Data = buffer;
  596.       }
  597.       else {
  598.          free( buffer );
  599.          return NULL;
  600.       }
  601.       return image;
  602.    }
  603.    else {
  604.       abort();
  605.    }
  606.    return NULL;  /* never get here */
  607. }
  608.  
  609.  
  610.  
  611. void gl_free_image( struct gl_image *image )
  612. {
  613.    if (image->Data) {
  614.       free(image->Data);
  615.    }
  616.    free(image);
  617. }
  618.